MCPForUnity/Editor/Helpers/PackageDetector.cs (2)

135-137: Limit scan scope to Assets/Packages to avoid heavy project-wide traversal.

Scanning the entire project root can walk Library, Temp, etc. Prefer Assets and Packages only.

Apply this diff:

-                // Find all MCPForUnityTools folders in project
-                var toolsFolders = System.IO.Directory.GetDirectories(projectRoot, "MCPForUnityTools", System.IO.SearchOption.AllDirectories);
+                // Find all MCPForUnityTools folders under Assets and Packages only
+                var toolsFolders = new System.Collections.Generic.List<string>();
+                string assetsDir = System.IO.Path.Combine(projectRoot, "Assets");
+                if (System.IO.Directory.Exists(assetsDir))
+                    toolsFolders.AddRange(System.IO.Directory.GetDirectories(assetsDir, "MCPForUnityTools", System.IO.SearchOption.AllDirectories));
+                string packagesDir = System.IO.Path.Combine(projectRoot, "Packages");
+                if (System.IO.Directory.Exists(packagesDir))
+                    toolsFolders.AddRange(System.IO.Directory.GetDirectories(packagesDir, "MCPForUnityTools", System.IO.SearchOption.AllDirectories));

---

181-213: Deduplicate GetToolsFolderIdentifier to avoid drift.

This logic is duplicated here and in ServerInstaller. Prefer a single source of truth.

• Change ServerInstaller.GetToolsFolderIdentifier(...) to internal static.
• Use that here and remove this duplicate method.

Proposed changes:

In ServerInstaller.cs (make method internal):

-        private static string GetToolsFolderIdentifier(string toolsFolderPath)
+        internal static string GetToolsFolderIdentifier(string toolsFolderPath)

In PackageDetector.cs (remove this method and call ServerInstaller.GetToolsFolderIdentifier(folder) where needed).

MCPForUnity/Editor/Helpers/ServerInstaller.cs (3)

421-423: Reduce scan scope to Assets/Packages for performance.

Avoid traversing Library/Temp etc. on each domain reload.

Apply this diff:

-                // Find all MCPForUnityTools folders
-                var toolsFolders = Directory.GetDirectories(projectRoot, "MCPForUnityTools", SearchOption.AllDirectories);
+                // Find all MCPForUnityTools folders under Assets and Packages only
+                var toolsFolders = new List<string>();
+                var assetsDir = Path.Combine(projectRoot, "Assets");
+                if (Directory.Exists(assetsDir))
+                    toolsFolders.AddRange(Directory.GetDirectories(assetsDir, "MCPForUnityTools", SearchOption.AllDirectories));
+                var packagesDir = Path.Combine(projectRoot, "Packages");
+                if (Directory.Exists(packagesDir))
+                    toolsFolders.AddRange(Directory.GetDirectories(packagesDir, "MCPForUnityTools", SearchOption.AllDirectories));

---

494-531: Expose GetToolsFolderIdentifier for reuse.

Make this helper internal so PackageDetector can reuse it and remove duplicate logic.

Apply this diff:

-        private static string GetToolsFolderIdentifier(string toolsFolderPath)
+        internal static string GetToolsFolderIdentifier(string toolsFolderPath)

---

483-487: Optional: log skipped tools for visibility.

You track skippedCount but don't surface it.

Apply this diff:

                 if (copiedCount > 0)
                 {
                     McpLog.Info($"Copied {copiedCount} Unity project tool(s) to server");
                 }
+                else if (skippedCount > 0)
+                {
+                    McpLog.Info($"All Unity project tools up-to-date ({skippedCount} skipped)");
+                }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

410-492: Prevent copy failures, avoid filename collisions, and limit scan scope.

• Ensure dest tools dir exists before File.Copy.
• Flat-copying .py into a shared tools root risks overwriting between multiple MCPForUnityTools folders (same filenames). Copy into a per-folder subdirectory keyed by folderIdentifier.
• Limit scan to Assets/ and Packages/ to avoid deep recursion into Library/.git and speed up. Also clean stale .py removed upstream.

Apply this diff:

 private static void CopyUnityProjectTools(string destToolsDir)
 {
     try
     {
         // Get Unity project root
         string projectRoot = Directory.GetParent(Application.dataPath)?.FullName;
         if (string.IsNullOrEmpty(projectRoot))
         {
             return;
         }
 
+        // Ensure destination tools directory exists
+        Directory.CreateDirectory(destToolsDir);
+
-        // Find all MCPForUnityTools folders
-        var toolsFolders = Directory.GetDirectories(projectRoot, "MCPForUnityTools", SearchOption.AllDirectories);
+        // Find all MCPForUnityTools folders (limit to Assets/ and Packages/)
+        var searchRoots = new[] { Path.Combine(projectRoot, "Assets"), Path.Combine(projectRoot, "Packages") }
+            .Where(Directory.Exists);
+        var toolsFolders = searchRoots
+            .SelectMany(root => Directory.GetDirectories(root, "MCPForUnityTools", SearchOption.AllDirectories))
+            .ToArray();
 
         int copiedCount = 0;
         int skippedCount = 0;
 
         foreach (var folder in toolsFolders)
         {
             // Generate unique identifier for this tools folder based on its parent directory structure
             // e.g., "MooseRunner_MCPForUnityTools" or "MyPackage_MCPForUnityTools"
             string folderIdentifier = GetToolsFolderIdentifier(folder);
-            string versionTrackingFile = Path.Combine(destToolsDir, $"{folderIdentifier}_version.txt");
+            string destToolFolder = Path.Combine(destToolsDir, folderIdentifier);
+            string versionTrackingFile = Path.Combine(destToolFolder, "_version.txt");
 
             // Read source version
             string sourceVersionFile = Path.Combine(folder, "version.txt");
             string sourceVersion = ReadVersionFile(sourceVersionFile) ?? "0.0.0";
 
             // Read installed version (tracked separately per tools folder)
             string installedVersion = ReadVersionFile(versionTrackingFile);
 
             // Check if update is needed (version different or no tracking file)
             bool needsUpdate = string.IsNullOrEmpty(installedVersion) || sourceVersion != installedVersion;
 
             if (needsUpdate)
             {
                 // Get all .py files (excluding __init__.py)
                 var pyFiles = Directory.GetFiles(folder, "*.py")
                     .Where(f => !Path.GetFileName(f).Equals("__init__.py", StringComparison.OrdinalIgnoreCase));
 
+                // Ensure per-tool destination exists
+                Directory.CreateDirectory(destToolFolder);
+
+                // Cleanup stale .py files that were removed upstream
+                try
+                {
+                    var sourceNames = new HashSet<string>(pyFiles.Select(f => Path.GetFileName(f)), StringComparer.OrdinalIgnoreCase);
+                    foreach (var destPy in Directory.GetFiles(destToolFolder, "*.py"))
+                    {
+                        if (!sourceNames.Contains(Path.GetFileName(destPy)))
+                        {
+                            File.Delete(destPy);
+                        }
+                    }
+                }
+                catch (Exception cleanupEx)
+                {
+                    McpLog.Warn($"Failed to cleanup stale files for {folderIdentifier}: {cleanupEx.Message}");
+                }
+
                 foreach (var pyFile in pyFiles)
                 {
                     string fileName = Path.GetFileName(pyFile);
-                    string destFile = Path.Combine(destToolsDir, fileName);
+                    string destFile = Path.Combine(destToolFolder, fileName);
 
                     try
                     {
                         File.Copy(pyFile, destFile, overwrite: true);
                         copiedCount++;
                         McpLog.Info($"Copied Unity project tool: {fileName} from {folderIdentifier} (v{sourceVersion})");
                     }
                     catch (Exception ex)
                     {
                         McpLog.Warn($"Failed to copy {fileName}: {ex.Message}");
                     }
                 }
 
                 // Update version tracking file
                 try
                 {
                     File.WriteAllText(versionTrackingFile, sourceVersion);
                 }
                 catch (Exception ex)
                 {
                     McpLog.Warn($"Failed to write version tracking file for {folderIdentifier}: {ex.Message}");
                 }
             }
             else
             {
                 skippedCount++;
             }
         }
 
         if (copiedCount > 0)
         {
             McpLog.Info($"Copied {copiedCount} Unity project tool(s) to server");
         }
     }
     catch (Exception ex)
     {
         McpLog.Warn($"Failed to scan Unity project for tools: {ex.Message}");
     }
 }

Note: If tools rely on package-style relative imports, consider copying their __init__.py into the per-folder subdir to preserve package semantics. Please confirm expected import pattern.

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

498-531: Consolidate GetToolsFolderIdentifier into a shared helper
Extract the duplicate logic from ServerInstaller.cs and PackageDetector.cs into a single utility method to keep identifier rules consistent.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

455-489: Don’t create per-folder dirs when no .py files; add to active set only if a tool exists.

Currently the subdir is created and left empty when no .py files are found. Move enumeration before creating the subdir and before adding to activeFolderIdentifiers.

Apply this diff:

-                    // Generate unique identifier for this tools folder based on its parent directory structure
-                    // e.g., "MooseRunner_MCPForUnityTools" or "MyPackage_MCPForUnityTools"
-                    string folderIdentifier = GetToolsFolderIdentifier(folder);
-                    activeFolderIdentifiers.Add(folderIdentifier);
-
-                    // Create per-folder subdirectory in destToolsDir
-                    string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
-                    Directory.CreateDirectory(destFolderSubdir);
-
-                    string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
-
-                    // Read source version
-                    string sourceVersionFile = Path.Combine(folder, "version.txt");
-                    string sourceVersion = ReadVersionFile(sourceVersionFile) ?? "0.0.0";
-
-                    // Read installed version (tracked separately per tools folder)
-                    string installedVersion = ReadVersionFile(versionTrackingFile);
-
-                    // Check if update is needed (version different or no tracking file)
-                    bool needsUpdate = string.IsNullOrEmpty(installedVersion) || sourceVersion != installedVersion;
-
-                    if (needsUpdate)
-                    {
-                        // Get all .py files (excluding __init__.py)
-                        var pyFiles = Directory.GetFiles(folder, "*.py")
-                            .Where(f => !Path.GetFileName(f).Equals("__init__.py", StringComparison.OrdinalIgnoreCase));
-                            
-                        // Skip folders with no .py files
-                        if (!pyFiles.Any())
-                        { 
-                            skippedCount++; 
-                            continue; 
-                        }
+                    // Get all .py files (excluding __init__.py)
+                    var pyFiles = Directory.GetFiles(folder, "*.py")
+                        .Where(f => !Path.GetFileName(f).Equals("__init__.py", StringComparison.OrdinalIgnoreCase));
+
+                    // Skip folders with no .py files (don't add to active set and don't create subdir)
+                    if (!pyFiles.Any())
+                    {
+                        skippedCount++;
+                        continue;
+                    }
+
+                    // Generate identifier only for valid tool folders and mark active
+                    string folderIdentifier = GetToolsFolderIdentifier(folder);
+                    activeFolderIdentifiers.Add(folderIdentifier);
+
+                    string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
+                    string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
+
+                    // Read versions
+                    string sourceVersionFile = Path.Combine(folder, "version.txt");
+                    string sourceVersion = ReadVersionFile(sourceVersionFile) ?? "0.0.0";
+                    string installedVersion = ReadVersionFile(versionTrackingFile);
+
+                    bool needsUpdate = string.IsNullOrEmpty(installedVersion) || sourceVersion != installedVersion;
+
+                    if (needsUpdate)
+                    {
+                        Directory.CreateDirectory(destFolderSubdir);

MCPForUnity/Editor/Helpers/ServerInstaller.cs (2)

435-447: Deduplicate “Packages” vs “Library/PackageCache” results.

Scanning both can find the same tool twice. Prefer the Packages path when both exist; skip PackageCache duplicates.

Would you like me to propose a small de-dupe map keyed by package folder name (preferring “Packages/” over “Library/PackageCache/”)?

---

480-489: Verify intent: excluding init.py and not copying subdirectories.

If tools use packages or one‑level submodules, skipping init.py and not copying subdirs may break imports.

• Option A: keep single‑file tool policy; document it clearly.
• Option B: copy one‑level subdirectories (skip pycache, venvs) and include init.py when present.
  Do you want a patch for Option B?

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

596-629: Critical: Address unresolved identifier collision and PackageCache issues.

The previous review identified two problems that remain unfixed:

1. PackageCache not handled: For paths like Library/PackageCache/com.example@1.0.0/Editor/MCPForUnityTools, the code doesn't recognize PackageCache as a valid root, falling back to the generic Editor_MCPForUnityTools identifier.

2. Collision risk: Multiple packages under the same parent produce identical identifiers. For example:

   • Assets/Plugins/Package1/Editor/MCPForUnityTools → Assets_Plugins_MCPForUnityTools
   • Assets/Plugins/Package2/Editor/MCPForUnityTools → Assets_Plugins_MCPForUnityTools

   These collisions cause tools to overwrite each other.

Apply the diff from the previous review to fix both issues:

 internal static string GetToolsFolderIdentifier(string toolsFolderPath)
 {
     try
     {
-        // Get parent directory name (e.g., "Editor" or package name)
-        DirectoryInfo parent = Directory.GetParent(toolsFolderPath);
-        if (parent == null) return "MCPForUnityTools";
-
-        // Walk up to find a distinctive parent (Assets/PackageName or Packages/PackageName)
-        DirectoryInfo current = parent;
-        while (current != null)
-        {
-            string name = current.Name;
-            DirectoryInfo grandparent = current.Parent;
-
-            // Stop at Assets, Packages, or if we find a package-like structure
-            if (grandparent != null &&
-                (grandparent.Name.Equals("Assets", StringComparison.OrdinalIgnoreCase) ||
-                 grandparent.Name.Equals("Packages", StringComparison.OrdinalIgnoreCase)))
-            {
-                return $"{grandparent.Name}_{name}_MCPForUnityTools";
-            }
-
-            current = grandparent;
-        }
-
-        // Fallback: use immediate parent
-        return $"{parent.Name}_MCPForUnityTools";
+        // toolsFolderPath → .../<PackageFolder>/Editor/MCPForUnityTools
+        var editorDir = Directory.GetParent(toolsFolderPath);      // Editor
+        var packageDir = editorDir?.Parent;                         // <PackageFolder>
+        if (packageDir == null) return "MCPForUnityTools";
+
+        // Find root (Assets / Packages / PackageCache)
+        DirectoryInfo current = packageDir;
+        while (current?.Parent != null)
+        {
+            var p = current.Parent;
+            if (p.Name.Equals("Assets", StringComparison.OrdinalIgnoreCase) ||
+                p.Name.Equals("Packages", StringComparison.OrdinalIgnoreCase) ||
+                p.Name.Equals("PackageCache", StringComparison.OrdinalIgnoreCase))
+            {
+                return $"{p.Name}_{current.Name}_MCPForUnityTools";
+            }
+            current = p;
+        }
+
+        // Fallback: use package dir name
+        return $"{packageDir.Name}_MCPForUnityTools";
     }
     catch
     {
         return "MCPForUnityTools";
     }
 }

This ensures unique identifiers by including the package folder name directly above Editor, preventing collisions between different packages under the same parent directory, and properly handling PackageCache locations.

MCPForUnity/Editor/Helpers/ServerInstaller.cs (1)

462-465: Consider deferring subdirectory creation until after version check.

The subdirectory is created on line 464 before checking if an update is needed on line 478. For up-to-date folders, this performs unnecessary directory creation operations.

Apply this diff to defer directory creation:

         string folderIdentifier = GetToolsFolderIdentifier(folder);
         activeFolderIdentifiers.Add(folderIdentifier);
 
-        // Create per-folder subdirectory in destToolsDir
-        string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
-        Directory.CreateDirectory(destFolderSubdir);
-
+        string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
         string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
 
         // Read source version
         string sourceVersionFile = Path.Combine(folder, "version.txt");
         string sourceVersion = ReadVersionFile(sourceVersionFile) ?? "0.0.0";
 
         // Read installed version (tracked separately per tools folder)
         string installedVersion = ReadVersionFile(versionTrackingFile);
 
         // Check if update is needed (version different or no tracking file)
         bool needsUpdate = string.IsNullOrEmpty(installedVersion) || sourceVersion != installedVersion;
 
         if (needsUpdate)
         {
+            // Create per-folder subdirectory in destToolsDir
+            Directory.CreateDirectory(destFolderSubdir);
+
             // Get all .py files (excluding __init__.py)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

MCPForUnity/Editor/Helpers/ServerInstaller.cs (2)

462-465: Avoid creating empty dest subdirs — create lazily after confirming .py files.

Create destFolderSubdir only when pyFiles.Any() and an update is needed; prevents noise from empty folders.

-                    // Create per-folder subdirectory in destToolsDir
-                    string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
-                    Directory.CreateDirectory(destFolderSubdir);
-
-                    string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
+                    // Prepare paths; create dest subdir lazily
+                    string destFolderSubdir = Path.Combine(destToolsDir, folderIdentifier);
+                    string versionTrackingFile = Path.Combine(destFolderSubdir, "version.txt");
...
-                        // Skip folders with no .py files
+                        // Skip folders with no .py files
                         if (!pyFiles.Any())
                         { 
                             skippedCount++; 
                             continue; 
                         }
 
+                        // Ensure destination subdir exists only when we actually copy
+                        Directory.CreateDirectory(destFolderSubdir);

Also applies to: 484-489

---

596-629: Identifier collisions for PackageCache — derive stable, unique names (critical).

Current logic doesn’t handle Library/PackageCache; many tools resolve to “Editor_MCPForUnityTools”, causing overwrites and bad cleanup.

-        internal static string GetToolsFolderIdentifier(string toolsFolderPath)
+        internal static string GetToolsFolderIdentifier(string toolsFolderPath)
         {
             try
             {
-                // Get parent directory name (e.g., "Editor" or package name)
-                DirectoryInfo parent = Directory.GetParent(toolsFolderPath);
-                if (parent == null) return "MCPForUnityTools";
-
-                // Walk up to find a distinctive parent (Assets/PackageName or Packages/PackageName)
-                DirectoryInfo current = parent;
-                while (current != null)
-                {
-                    string name = current.Name;
-                    DirectoryInfo grandparent = current.Parent;
-
-                    // Stop at Assets, Packages, or if we find a package-like structure
-                    if (grandparent != null &&
-                        (grandparent.Name.Equals("Assets", StringComparison.OrdinalIgnoreCase) ||
-                         grandparent.Name.Equals("Packages", StringComparison.OrdinalIgnoreCase)))
-                    {
-                        return $"{grandparent.Name}_{name}_MCPForUnityTools";
-                    }
-
-                    current = grandparent;
-                }
-
-                // Fallback: use immediate parent
-                return $"{parent.Name}_MCPForUnityTools";
+                // toolsFolderPath .../<PackageFolder>/Editor/MCPForUnityTools
+                var editorDir = Directory.GetParent(toolsFolderPath);       // Editor
+                var packageDir = editorDir?.Parent;                         // <PackageFolder>
+                if (packageDir == null) return "MCPForUnityTools";
+
+                // Find root (Assets / Packages / PackageCache)
+                DirectoryInfo current = packageDir;
+                while (current?.Parent != null)
+                {
+                    var p = current.Parent;
+                    if (p.Name.Equals("Assets", StringComparison.OrdinalIgnoreCase) ||
+                        p.Name.Equals("Packages", StringComparison.OrdinalIgnoreCase) ||
+                        p.Name.Equals("PackageCache", StringComparison.OrdinalIgnoreCase))
+                    {
+                        return $"{p.Name}_{current.Name}_MCPForUnityTools";
+                    }
+                    current = p;
+                }
+
+                // Fallback: use package dir name
+                return $"{packageDir.Name}_MCPForUnityTools";
             }
             catch
             {
                 return "MCPForUnityTools";
             }
         }

MCPForUnity/Editor/Helpers/ServerInstaller.cs (2)

425-447: Reduce duplication: prefer Packages over PackageCache and stream directory enumeration.

• Use Directory.EnumerateDirectories to avoid loading huge lists.
• Skip PackageCache tools when the corresponding Packages//Editor/MCPForUnityTools exists to prevent duplicate installs.

Example approach:

• Keep searchRoots ordered: Assets → Packages → PackageCache.
• When iterating PackageCache folders, map “com.pkg@x.y.z” → “com.pkg” and skip if Packages/com.pkg/Editor/MCPForUnityTools exists.

---

449-451: Remove unused skippedCount or log it.

It’s incremented but never used.

-                int copiedCount = 0;
-                int skippedCount = 0;
+                int copiedCount = 0;
...
-                        { 
-                            skippedCount++; 
-                            continue; 
-                        }
+                        { 
+                            continue; 
+                        }
...
-                        skippedCount++;

Also applies to: 487-489, 525-526

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro